.TH std::nullptr_t 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::nullptr_t \- std::nullptr_t

.SH Synopsis
   Defined in header <cstddef>
   using nullptr_t = decltype(nullptr);  \fI(since C++11)\fP

   std::nullptr_t is the type of the null pointer literal, nullptr. It is a distinct
   type that is not itself a pointer type or a pointer to member type. Its values are
   null pointer constants (see NULL), and may be implicitly converted to any pointer
   and pointer to member type.

   sizeof(std::nullptr_t) is equal to sizeof(void *).

.SH Notes

   The C++ standard requires <stddef.h> to place the contents of <cstddef> in the
   global namespace, and thereby requires nullptr_t to be available in the global
   namespace when <stddef.h> is included.

   nullptr_t is not a part of C until C23.

   It is unspecified whether the declaration of std::nullptr_t is available in any
   other standard library header. An implementation may avoid introducing this name
   even when the standard requires std::nullptr_t to be used, by e.g. spelling
   decltype(nullptr) instead.

.SH Example

   If two or more overloads accept different pointer types, an overload for
   std::nullptr_t is necessary to accept a null pointer argument.


// Run this code

 #include <cstddef>
 #include <iostream>

 void f(int*)
 {
    std::cout << "Pointer to integer overload\\n";
 }

 void f(double*)
 {
    std::cout << "Pointer to double overload\\n";
 }

 void f(std::nullptr_t)
 {
    std::cout << "null pointer overload\\n";
 }

 int main()
 {
     int* pi{};
     double* pd{};

     f(pi);
     f(pd);
     f(nullptr); // would be ambiguous without void f(nullptr_t)
     // f(0);    // ambiguous call: all three functions are candidates
     // f(NULL); // ambiguous if NULL is an integral null pointer constant
                 // (as is the case in most implementations)
 }

.SH Output:

 Pointer to integer overload
 Pointer to double overload
 null pointer overload

.SH See also

   nullptr\fI(C++11)\fP  the pointer literal which specifies a null pointer value
   NULL            implementation-defined null pointer constant
                   (macro constant)
   is_null_pointer checks if a type is std::nullptr_t
   \fI(C++14)\fP         \fI(class template)\fP
   C documentation for
   nullptr_t
